{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2、深层神经网络（DNN）分类模型",
   "id": "1a6c85778bf61dd1"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.107466Z",
     "start_time": "2025-03-07T11:37:21.946128Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import os\n",
    "import sys\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms  # 将图片转换为tensor"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 打印系统信息",
   "id": "1f9d7f5ef9f5b40e"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.123757Z",
     "start_time": "2025-03-07T11:37:25.107466Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "id": "cb10e18f5766dc8d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.1\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据集以及数据预处理",
   "id": "c668a4ef75f01060"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.151985Z",
     "start_time": "2025-03-07T11:37:25.123757Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将图片转换为tensor\n",
    "    transforms.Normalize((0.2860,), (0.3205,))  # 归一化\n",
    "])\n",
    "\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "batch_size = 32\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size, shuffle=False)"
   ],
   "id": "cdf81ebed569ebf4",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义模型",
   "id": "ac6d8c94ed111ca8"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.162767Z",
     "start_time": "2025-03-07T11:37:25.152990Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层:所谓的DNN就是多个全连接层堆叠而成add_module()方法可以添加多个模块\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):  #判断m是否为全连接层\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        # x = self.transforms(x)  #标准化\n",
    "        x = self.flatten(x)\n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "total = 0\n",
    "# 计算模型参数数量\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total  #模型参数数量\n"
   ],
   "id": "dd323365c40aa6a6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(271410)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义损失函数和优化器",
   "id": "20e3452a91e25d4a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.165662Z",
     "start_time": "2025-03-07T11:37:25.162767Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)"
   ],
   "id": "22f030d2dbb1c736",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义评估函数",
   "id": "934c2422f99f4639"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.199125Z",
     "start_time": "2025-03-07T11:37:25.165662Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_func):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_func(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)  # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "2c91772c89ffe099",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练函数",
   "id": "f4a4d0957eadc3e1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:37:25.204923Z",
     "start_time": "2025-03-07T11:37:25.199125Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_func,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_func(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_func)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "e1a5883fb896c195",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:39:44.946319Z",
     "start_time": "2025-03-07T11:37:25.204923Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_func,\n",
    "    optimizer,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "2ef7b075af3b4fe2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/18750 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "dd0ba9e4b296417fa9b111c73f42b369"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:39:45.040076Z",
     "start_time": "2025-03-07T11:39:44.946319Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    # print(train_df.head())\n",
    "    # print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)  #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))  #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data = range(0, train_df.index[-1], 5000)  #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))  #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "609d7d8c6d1471a6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T11:39:46.031738Z",
     "start_time": "2025-03-07T11:39:45.041080Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_func)\n",
    "print(f\"loss:{loss:.4f}\\naccuracy:{acc:.4f}\")"
   ],
   "id": "a132c5e875313c06",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:0.3656\n",
      "accuracy:0.8713\n"
     ]
    }
   ],
   "execution_count": 10
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
